home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 January - Disc 2 / Macworld (1999-01) (Disk 2).dmg / Serious Demos / Symbolic Composer 4.2 / Environment / Projects / Questions & Answers / Q&A Basic / Calculating many values next >
Encoding:
Text File  |  1998-10-26  |  4.9 KB  |  142 lines  |  [TEXT/ScoM]
  1. i have many algorithms that i would like to explore that are not
  2. expressible in terms of strings of symbols and lengths, but would
  3. better be expressed as a list of midi events themselves.  i realize
  4. that this would totally bypass your convenient tonality/zone stuff,
  5. but i still think it's worth exploring.
  6.  
  7. the reason why i want to break away from the existing paradigm is
  8. because my algorithms are multi-valued functions.  there are more
  9. than one event occurring at the same start time, and they all might
  10. have different end times, and velocities.  i just don't know how
  11. to express these things as strings of symbols and lengths.
  12.  
  13. for example, here is a silly algorithm that i'd like to try, written
  14. in C pseudo-code (please don't think that my understanding of julia
  15. sets is so naive as to think that this algorithm is useful):
  16.  
  17.   // i is the time axis, traversed at .1 second intervals.
  18.   for(i=0; i< 5; i += 0.1) {
  19.     // j is the midi note number axis
  20.     for(j=0; j< 127; j++) {
  21.       if(isInJuliaSet(i/5.0,j/127.)) {
  22.         note[numnotes].on = i;
  23.         note[numnotes].off = i+0.1;
  24.         note[numnotes].midinotenumber = j;
  25.         note[numnotes].velocity = 100;
  26.         numnotes++;
  27.       }
  28.     }
  29.   }
  30.  
  31. i realize that this is very procedural, rather than functional, programming.
  32. but the "note" array could be made into a list, and many SCOM functions could
  33. be performed on this new object (most of them would have to be extended to be
  34. performed on collections such as these).
  35.  
  36. i just can't see how to write alogorithms like these under the current SCOM
  37. paradigm.  if you have an easy way, i'm open to you educating me.
  38.  
  39. >  // i is the time axis, traversed at .1 second intervals.
  40. >  for(i=0; i< 5; i += 0.1) {
  41. >    // j is the midi note number axis
  42. >    for(j=0; j< 127; j++) {
  43. >      if(isInJuliaSet(i/5.0,j/127.)) {
  44. >        note[numnotes].on = i;
  45. >        note[numnotes].off = i+0.1;
  46. >        note[numnotes].midinotenumber = j;
  47. >        note[numnotes].velocity = 100;
  48. >        numnotes++;
  49. >      }
  50. >    }
  51. >  }
  52. >
  53.  
  54. You can calculate multiple values and then push them into stacks,
  55. which you then reverse and return as multiple values. Now you can
  56. bind the values to instruments, and as they are separate you can
  57. process them further in the usual way.
  58.  
  59. Here you define note, length, duration and velocity stacks. In the
  60. loops you push values to them. Note that here each note is 1/32
  61. length, you could as well calculate it and make it a length symbol with
  62. compress: (compress (list 2 '/ 16)). Same applies to duration.
  63. The note number is here directly converted to a symbol with
  64. integer-to-symbol.
  65.  
  66. (defun julia-set ()
  67.   (let ((note nil)
  68.         (length nil)
  69.         (duration nil)
  70.         (velocity nil)
  71.         (resolution 0.1))
  72.     (dotimes (i (round (/ 5 resolution)))
  73.       (dotimes (j 127)
  74.         (when (is-in-juliaset (/ i (round (/ 5 resolution))) 
  75.                               (/ j 127))
  76.           (push '1/32 length)
  77.           (push '1/32 duration)
  78.           (push (integer-to-symbol j) note)
  79.           (push 100 velocity))))
  80.     (values (nreverse note)
  81.             (nreverse length)
  82.             (nreverse duration)
  83.             (nreverse velocity))))
  84.  
  85. you have to specify this function:
  86.  
  87. (defun is-in-juliaset (x y)
  88.   t)
  89.  
  90. ;;;;;;;;; score example
  91.  
  92. (defparameter symbol-pattern nil)
  93. (defparameter length-pattern nil)
  94. (defparameter duration-pattern nil)
  95. (defparameter velocity-pattern nil)
  96.  
  97. ; now your julia-set returns symbols, lengths, durations and velocities
  98. ; the multiple-value-setq bounds the results to the symbol-pattern etc variables
  99.  
  100. (multiple-value-setq (symbol-pattern length-pattern duration-pattern velocity-pattern)
  101.   (julia-set))
  102.  
  103. (def-orchestra 'orchestra
  104.    all-instruments (julia1)
  105. )
  106.  
  107. ; here you connect the calculated values from the variables to the section slots
  108.  
  109. (def-section verse
  110.    julia1
  111.      channel 1
  112.      zone (make-zone length-pattern)
  113.      tonality (activate-tonality (chromatic c 0))
  114.      length length-pattern
  115.      duration duration-pattern
  116.      symbol symbol-pattern
  117.      velocity velocity-pattern
  118. )
  119.  
  120. (midiport :printer)
  121.  
  122. (def-tempo 120)
  123.  
  124. (play-file-p nil
  125.    all-instruments '(verse)
  126. )
  127.  
  128. >i realize that this is very procedural, rather than functional, programming.
  129. >but the "note" array could be made into a list, and many SCOM functions could
  130. >be performed on this new object (most of them would have to be extended to be
  131. >performed on collections such as these).
  132.  
  133. I suggest keeping them separate patterns like in the above, since
  134. otherwise you have to spend lots of time writing functions to support
  135. processing this new data structure. In once made a combined way to
  136. treat patterns called 'motives'. They are still part of the system and
  137. should work ok, but it takes time to make motive processors. The motives
  138. should be found in the more examples folder. You can try modifying
  139. the juliaset function to generate a motive with all the values, and 
  140. then use the motive within def-section to define instrument values.
  141.  
  142.